/*
 * Importa_Disciplinas.java
 *
 * Created on 26/Jun/2008, 20:20:33
 */
package webapp_teste;

import com.sun.data.provider.RowKey;
import com.sun.data.provider.impl.CachedRowSetDataProvider;
import com.sun.rave.web.ui.appbase.AbstractPageBean;
import com.sun.sql.rowset.CachedRowSetXImpl;
import com.sun.webui.jsf.component.Button;
import com.sun.webui.jsf.component.StaticText;
import com.sun.webui.jsf.component.TextArea;
import com.sun.webui.jsf.component.Upload;
import com.sun.webui.jsf.model.UploadedFile;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import javax.faces.FacesException;

/**
 * <p>Page bean that corresponds to a similarly named JSP page.  This
 * class contains component definitions (and initialization code) for
 * all components that you have defined on this page, as well as
 * lifecycle methods and event handlers where you may add behavior
 * to respond to incoming events.</p>
 *
 * @author Consultor
 */
public class Importa_Disciplinas extends AbstractPageBean {

    
    // <editor-fold defaultstate="collapsed" desc="Managed Component Definition">
    /**
     * <p>Automatically managed component initialization.  <strong>WARNING:</strong>
     * This method is automatically generated, so any user-specified code inserted
     * here is subject to being replaced.</p>
     */
    private void _init() throws Exception {
        alunosRowSet.setDataSourceName("java:comp/env/jdbc/ADMIN_ApacheDerby");
        alunosRowSet.setCommand("SELECT * FROM ADMIN.ALUNOS");
        alunosRowSet.setTableName("ALUNOS");
        alunosDataProvider.setCachedRowSet((javax.sql.rowset.CachedRowSet) getValue("#{Importa_Disciplinas.alunosRowSet}"));
        alunoscriteriosavalDataProvider.setCachedRowSet((javax.sql.rowset.CachedRowSet) getValue("#{Importa_Disciplinas.alunoscriteriosavalRowSet}"));
        alunoscriteriosavalRowSet.setDataSourceName("java:comp/env/jdbc/ADMIN_ApacheDerby");
        alunoscriteriosavalRowSet.setCommand("SELECT * FROM ADMIN.ALUNOSCRITERIOSAVAL");
        alunoscriteriosavalRowSet.setTableName("ALUNOSCRITERIOSAVAL");
    }
    private Upload fileUploadImport = new Upload();

    public Upload getFileUploadImport() {
        return fileUploadImport;
    }

    public void setFileUploadImport(Upload u) {
        this.fileUploadImport = u;
    }
    private CachedRowSetDataProvider alunosDataProvider = new CachedRowSetDataProvider();

    public CachedRowSetDataProvider getAlunosDataProvider() {
        return alunosDataProvider;
    }

    public void setAlunosDataProvider(CachedRowSetDataProvider crsdp) {
        this.alunosDataProvider = crsdp;
    }
    private CachedRowSetXImpl alunosRowSet = new CachedRowSetXImpl();

    public CachedRowSetXImpl getAlunosRowSet() {
        return alunosRowSet;
    }

    public void setAlunosRowSet(CachedRowSetXImpl crsxi) {
        this.alunosRowSet = crsxi;
    }
    private Button btnValidar = new Button();

    public Button getBtnValidar() {
        return btnValidar;
    }

    public void setBtnValidar(Button b) {
        this.btnValidar = b;
    }
    private TextArea textArea1 = new TextArea();

    public TextArea getTextArea1() {
        return textArea1;
    }

    public void setTextArea1(TextArea ta) {
        this.textArea1 = ta;
    }
    private StaticText stxtNomeFicheiro = new StaticText();

    public StaticText getStxtNomeFicheiro() {
        return stxtNomeFicheiro;
    }

    public void setStxtNomeFicheiro(StaticText st) {
        this.stxtNomeFicheiro = st;
    }
    private StaticText stxtTipoFicheiro = new StaticText();

    public StaticText getStxtTipoFicheiro() {
        return stxtTipoFicheiro;
    }

    public void setStxtTipoFicheiro(StaticText st) {
        this.stxtTipoFicheiro = st;
    }
    private StaticText stxtTamanhoFicheiro = new StaticText();

    public StaticText getStxtTamanhoFicheiro() {
        return stxtTamanhoFicheiro;
    }

    public void setStxtTamanhoFicheiro(StaticText st) {
        this.stxtTamanhoFicheiro = st;
    }
    private CachedRowSetDataProvider alunoscriteriosavalDataProvider = new CachedRowSetDataProvider();

    public CachedRowSetDataProvider getAlunoscriteriosavalDataProvider() {
        return alunoscriteriosavalDataProvider;
    }

    public void setAlunoscriteriosavalDataProvider(CachedRowSetDataProvider crsdp) {
        this.alunoscriteriosavalDataProvider = crsdp;
    }
    private CachedRowSetXImpl alunoscriteriosavalRowSet = new CachedRowSetXImpl();

    public CachedRowSetXImpl getAlunoscriteriosavalRowSet() {
        return alunoscriteriosavalRowSet;
    }

    public void setAlunoscriteriosavalRowSet(CachedRowSetXImpl crsxi) {
        this.alunoscriteriosavalRowSet = crsxi;
    }
    private StaticText stxtIdDisciplina = new StaticText();

    public StaticText getStxtIdDisciplina() {
        return stxtIdDisciplina;
    }

    public void setStxtIdDisciplina(StaticText st) {
        this.stxtIdDisciplina = st;
    }

    // </editor-fold>
    /**
     * <p>Construct a new Page bean instance.</p>
     */
    public Importa_Disciplinas() {
    }

    /**
     * <p>Callback method that is called whenever a page is navigated to,
     * either directly via a URL, or indirectly via page navigation.
     * Customize this method to acquire resources that will be needed
     * for event handlers and lifecycle methods, whether or not this
     * page is performing post back processing.</p>
     * 
     * <p>Note that, if the current request is a postback, the property
     * values of the components do <strong>not</strong> represent any
     * values submitted with this request.  Instead, they represent the
     * property values that were saved for this view when it was rendered.</p>
     */
    @Override
    public void init() {
        // Perform initializations inherited from our superclass
        super.init();
        // Perform application initialization that must complete
        // *before* managed components are initialized
        // TODO - add your own initialiation code here

        // <editor-fold defaultstate="collapsed" desc="Managed Component Initialization">
        // Initialize automatically managed components
        // *Note* - this logic should NOT be modified
        try {
            _init();
        } catch (Exception e) {
            log("Importa_Disciplinas Initialization Failure", e);
            throw e instanceof FacesException ? (FacesException) e : new FacesException(e);
        }

    // </editor-fold>
    // Perform application initialization that must complete
    // *after* managed components are initialized
    // TODO - add your own initialization code here
    }

    /**
     * <p>Callback method that is called after the component tree has been
     * restored, but before any event processing takes place.  This method
     * will <strong>only</strong> be called on a postback request that
     * is processing a form submit.  Customize this method to allocate
     * resources that will be required in your event handlers.</p>
     */
    @Override
    public void preprocess() {
    }

    /**
     * <p>Callback method that is called just before rendering takes place.
     * This method will <strong>only</strong> be called for the page that
     * will actually be rendered (and not, for example, on a page that
     * handled a postback and then navigated to a different page).  Customize
     * this method to allocate resources that will be required for rendering
     * this page.</p>
     */
    @Override
    public void prerender() {
    }

    /**
     * <p>Callback method that is called after rendering is completed for
     * this request, if <code>init()</code> was called (regardless of whether
     * or not this was the page that was actually rendered).  Customize this
     * method to release resources acquired in the <code>init()</code>,
     * <code>preprocess()</code>, or <code>prerender()</code> methods (or
     * acquired during execution of an event handler).</p>
     */
    @Override
    public void destroy() {
        alunosDataProvider.close();
        alunoscriteriosavalDataProvider.close();
    }

    /**
     * <p>Return a reference to the scoped data bean.</p>
     *
     * @return reference to the scoped data bean
     */
    protected RequestBean1 getRequestBean1() {
        return (RequestBean1) getBean("RequestBean1");
    }

    /**
     * <p>Return a reference to the scoped data bean.</p>
     *
     * @return reference to the scoped data bean
     */
    protected ApplicationBean1 getApplicationBean1() {
        return (ApplicationBean1) getBean("ApplicationBean1");
    }

    /**
     * <p>Return a reference to the scoped data bean.</p>
     *
     * @return reference to the scoped data bean
     */
    protected SessionBean1 getSessionBean1() {
        return (SessionBean1) getBean("SessionBean1");
    }

    private CachedRowSetDataProvider getDataProvider() {
        return this.getSessionBean1().getDisciplinasDataProvider();
    }

    public String btnHome_action() {
        // TODO: Process the action. Return value is a navigation
        // case name where null will return to the same page.
        return "Importa_Home";
    }

    public String btnValidar_action() throws FileNotFoundException, IOException {

        UploadedFile uploadedFile = (UploadedFile) fileUploadImport.getUploadedFile();
        String uploadedFileName;
        
        if (uploadedFile != null) {
            uploadedFileName = uploadedFile.getOriginalName();
            String justFileName;

            int index = uploadedFileName.lastIndexOf('/');

            if (index >= 0) {
                justFileName = uploadedFileName.substring(index + 1);
            } else {
                // Try backslash
                index = uploadedFileName.lastIndexOf('\\');
                if (index >= 0) {
                    justFileName = uploadedFileName.substring(index + 1);
                } else {
                    // No forward or back slashes
                    justFileName = uploadedFileName;
                }
            }

            this.stxtNomeFicheiro.setValue(justFileName);
            Long uploadedFileSize = new Long(uploadedFile.getSize());
            this.stxtTamanhoFicheiro.setValue(uploadedFileSize);
            String uploadedFileType = uploadedFile.getContentType();
            this.stxtTipoFicheiro.setValue(uploadedFileType);

            String idDisciplina = justFileName.substring(0, justFileName.lastIndexOf("."));
            this.stxtIdDisciplina.setValue(idDisciplina);


            //this.delData(idDisciplina);
            //this.addData(idDisciplina, uploadedFile.getOriginalName());
            String line;
            String campo[];
            BufferedReader fIn=null;

            try {
                fIn = new BufferedReader(new FileReader(uploadedFile.getOriginalName()));

                while ((line = fIn.readLine()) != null) {

                    campo = line.split("[comma]");

                    RowKey newRow = getAlunosDataProvider().appendRow();
                    getAlunosDataProvider().setCursorRow(newRow);

                    getAlunosDataProvider().setValue("IDDISCIPLINA", campo[0]);
                    getAlunosDataProvider().setValue("IDALUNO", campo[1]);
                    getAlunosDataProvider().setValue("NOME", campo[2]);
                    getAlunosDataProvider().setValue("NOTA", "0");

                    getAlunosDataProvider().commitChanges();
                    getAlunosDataProvider().refresh();

                }

                if (fIn != null) {
                    fIn.close();
                }

            } catch (Exception ex) {
                warn("Erro na importação do ficheiro." + ex.toString());
            }

            try {
                this.textArea1.setText(uploadedFile.getAsString());
            } catch (Exception e) {
                warn("Erro ao tentar ler o ficheiro.");
            }

        }
        return null;
    }

    private void addData(String idDisciplina, String fileName) {
        String line;
        String campo[];
        BufferedReader fIn;

        try {
            fIn = new BufferedReader(new FileReader(fileName));

            while ((line = fIn.readLine()) != null) {

                campo = line.split("[comma]");

                RowKey newRow = getAlunosDataProvider().appendRow();
                getAlunosDataProvider().setCursorRow(newRow);

                getAlunosDataProvider().setValue("IDDISCIPLINA", idDisciplina);
                getAlunosDataProvider().setValue("IDALUNO", campo[1]);
                getAlunosDataProvider().setValue("NOME", campo[2]);
                getAlunosDataProvider().setValue("NOTA", "0");

                getAlunosDataProvider().commitChanges();
            //getAlunosDataProvider().refresh();

            }

            if (fIn != null) {
                fIn.close();
            }

        } catch (Exception ex) {
            warn("Erro na importação do ficheiro." + ex.toString());
        }

    }//    private void delData(String idDisciplina) {
//        try {
//            while (getAlunosRowSet().next()) {
//                if (getAlunosDataProvider().cursorFirst()) {
//                for (int i = 0; i < getAlunosDataProvider().getRowCount(); i++) {
//                if (getAlunosDataProvider().getValue("IDDISCIPLINA").equals(idDisciplina)) {
//
//                    RowKey rowKey = this.getAlunosDataProvider().getCursorRow();
//
//                    if (this.getAlunosDataProvider().canRemoveRow(rowKey)) {
//                        try {
//                            this.getAlunosDataProvider().removeRow(rowKey);
//                            this.getAlunosDataProvider().commitChanges();
//                        } catch (Exception ex) {
//                            warn("Não é possível apagar este registo.");
//                        }
//                    }
//
//                    getAlunosDataProvider().cursorNext();
//                      }
//                }
//            }
//        } catch (SQLException ex) {
//            Logger.getLogger(Importa_Disciplinas.class.getName()).log(Level.SEVERE, null, ex);
//        }
//
//        this.getAlunosDataProvider().refresh();
//    }    
}

